{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Compare Model Zoo Benchmark performance between Intel optimized and stock PyTorch\n",
    "\n",
    "This jupyter notebook will help you evaluate performance benefits from Intel-optimized Tensorflow via several pre-trained models from Intel Model Zoo. \n",
    "The notebook will show users a bar chart like below for performance comparison among Stock and Intel Tensorflow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images\\perf_comparison.png\"  />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get Platform Information "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ignore all warning messages\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/tmp/models/docs/notebooks/perf_analysis/pytorch/profiling/../../../../../benchmarks/common\n",
      "==================== CPU Info ====================\n",
      "Physical cores per socket: 28\n",
      "Total physical cores: 56\n",
      "Max Frequency: 4000.0\n",
      "Min Frequency: 1000.0\n",
      "Socket Number: 2\n",
      "==================== Memory Information ====================\n",
      "Total:  251 GB\n"
     ]
    }
   ],
   "source": [
    "from profiling.profile_utils import PlatformUtils\n",
    "plat_utils = PlatformUtils()\n",
    "plat_utils.dump_platform_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='section_1'></a>\n",
    "# Section 1: Run the benchmark on the selected Jupyter Kernels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 1: Check TensorFlow version and MKL enablement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We are using PyTorch version 1.7.0a0+e85d494\n",
      "IPEX version: 1.2.0\n",
      "MKL enabled: False\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "print (\"We are using PyTorch version\", torch.__version__)\n",
    "try:\n",
    "    import intel_pytorch_extension as ipex\n",
    "    print(\"IPEX version: {}\".format(ipex.__version__))\n",
    "    has_ipex = True\n",
    "except ImportError:\n",
    "    print(\"WARNING: IPEX not available\")\n",
    "    has_ipex = False\n",
    "search_str=\"USE_MKL=\"\n",
    "offset = len(search_str)\n",
    "config_str = torch.__config__.show()\n",
    "idx = config_str.find(search_str)\n",
    "if config_str[idx+offset:idx+offset+2] == \"ON\":\n",
    "    on_mkl = True\n",
    "else:\n",
    "    on_mkl = False\n",
    "print(\"MKL enabled:\", on_mkl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2: Configure parameters for launch_benchmark.py according to the selected Topology"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2.1: List out the supported topologies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Supported topologies: \n",
      " 0: resnet50 infer fp32 \n",
      " 1: vgg16 infer fp32 \n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "from profiling.profile_utils import ConfigFile\n",
    "\n",
    "accuracy_only=False\n",
    "\n",
    "config = ConfigFile()\n",
    "sections = config.read_supported_section(accuracy_only=accuracy_only)\n",
    "print(\"Supported topologies: \")\n",
    "index = 0 \n",
    "for section in sections:\n",
    "    print(\" %d: %s \" %(index, section))\n",
    "    index+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2.2: Pick a topology. \n",
    "#### ACTION : Please select one supported topology and change topo_index accordingly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# User picks a topology, Batch Size, and number of required threads\n",
    "## USER INPUT\n",
    "topo_index=0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List out the selected topology name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vgg16 infer fp32\n"
     ]
    }
   ],
   "source": [
    "if topo_index >= len(sections):\n",
    "    print(\"ERROR! please input a topo_index within range\")\n",
    "else:\n",
    "    topology_name=sections[topo_index]\n",
    "    print(topology_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/tmp/models/docs/notebooks/perf_analysis/pytorch/../../../../\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "# Users should change ModelZooRoot path according to their environment\n",
    "## USER INPUT\n",
    "current_path = os.getcwd()\n",
    "os.environ['ModelZooRoot'] = current_path + \"/../../../../\"\n",
    "print(os.environ['ModelZooRoot'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Check those mandatory python scripts after users assign ModelZooRoot and ProfileUtilsRoot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "sys.path.append(os.environ['ModelZooRoot']+os.sep+'benchmarks/common/')\n",
    "from platform_util import CPUInfo \n",
    "cpu_info = CPUInfo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU count per socket: 28  \n",
      "Socket count: 2\n"
     ]
    }
   ],
   "source": [
    "import psutil\n",
    "import subprocess\n",
    "import os\n",
    "cpu_count = cpu_info.cores_per_socket\n",
    "cpu_socket_count =  cpu_info.sockets\n",
    "print(\"CPU count per socket:\" ,  cpu_count ,\" \\nSocket count:\",cpu_socket_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ACTION: Users can change the value of thread_number and batch_size to see different performance\n",
    "1. thread_umber: the value will apply to num_cores parameters in launch_benchmark.py  \n",
    "2. utilized_socket_number:  the value will apply to the socket-id parameter in launch_benchmark.py \n",
    "3. num_inter_threads: the value will  apply to the num-inter-threads parameter in launch_benchmark.py \n",
    "4. num_intra_threads: the value will  apply to the num-intra-threads parameter in launch_benchmark.py \n",
    "5. batch_size: the value will apply to the batch_size parameter in launch_benchmark.py \n",
    "6. log_folder: the folder where the logs are stored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "## USER INPUT\n",
    "thread_number=2 \n",
    "utilized_socket_number=2 #cpu_socket_count\n",
    "num_inter_threads = utilized_socket_number\n",
    "num_intra_threads = thread_number\n",
    "batch_size=32\n",
    "log_folder=os.getcwd() + os.sep + \"logs\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "current_path = os.getcwd()\n",
    "log_dir = os.path.join(current_path, \"logs\")\n",
    "log_filename = topology_name.replace(' ', '_') + '.log'\n",
    "log_path = os.path.join(log_dir, log_filename)\n",
    "from torch.distributed import launch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2.3: get required data and files if needed.\n",
    "No action if there is no output from this below cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the parameters from config\n",
    "config = ConfigFile()\n",
    "config.read_config(topology_name)\n",
    "if config.data_download != '' and config.data_location == '':\n",
    "    print(\"\\nPlease follow below command to get the data : \")\n",
    "    val = config.read_value_from_section(topology_name, 'data-download')\n",
    "    print(val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ACTION: Users set the configuration in topo.ini for those required data and files\n",
    "1. data_download_path: the value will be set as data-location parameters in topo.ini for the related topology.\n",
    "2. model_source_dir: the value will be set as the model-source-dir parameter in topo.ini for the related topology such as Wide and Deep. Those models use tensorflow-models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "## USER INPUT\n",
    "data_download_path = ''\n",
    "model_source_dir = ''\n",
    "\n",
    "# Overwrite configurations in topo.ini\n",
    "config = ConfigFile()\n",
    "config.read_config(topology_name)\n",
    "\n",
    "if config.data_download != '' and data_download_path != '':\n",
    "    config.write_value_from_section(topology_name, 'data-location', data_download_path)\n",
    "    config.data_location = data_download_path\n",
    "    \n",
    "if accuracy_only == True and config.data_location == '':\n",
    "    print(\"ERROR! STOP! need data for accuacy evaluatoin!\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2.4: Prepare pre-trained model and model parameters for running the benchmark\n",
    "1. Get related parameters according to selected topology\n",
    "2. Get pretrained model if needed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['torch.distributed.launch', '--nnodes=2', '--node_rank=2', '--nproc_per_node=2', '--use_env', '/tmp/models/docs/notebooks/perf_analysis/pytorch/../../../..//models/image_recognition/pytorch/common/main.py', '--batch-size', '32', '--arch', 'vgg16', '--dummy', '--evaluate', '--pretrained', '--ipex', '--precision', 'fp32', '--jit', '--warmup-iterations', '30', '--log-path=/tmp/models/docs/notebooks/perf_analysis/pytorch/logs/vgg16_infer_fp32.log']\n"
     ]
    }
   ],
   "source": [
    "config = ConfigFile()\n",
    "configvals = []\n",
    "# Get common parameters according to users' inputs\n",
    "params = [\"torch.distributed.launch\"]\n",
    "params.extend(config.get_launch_parameters(configvals, thread_number=thread_number,\n",
    "                                socket_number=utilized_socket_number, num_inter_threads=num_inter_threads,\n",
    "                                num_intra_threads=num_intra_threads,\n",
    "                                accuracy_only=False))\n",
    "main_script = os.environ['ModelZooRoot']+os.sep+'models/image_recognition/pytorch/common/main.py'\n",
    "params += [main_script]\n",
    "params.extend(config.get_main_parameters(topology_name = topology_name.split(\" \")[0], mode = \"infer\",\n",
    "                                         batch_size=batch_size, has_ipex = has_ipex,\n",
    "                                         precision=\"fp32\", warmup_iter=30, log_path=log_path))\n",
    "\n",
    "    \n",
    "sys.argv=params\n",
    "print(sys.argv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2.5: Create a CSV file to log the performance numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "file exists\n"
     ]
    }
   ],
   "source": [
    "from profiling.profile_utils import PerfPresenter\n",
    "job_type = topology_name.split(' ')[1]#'inference'\n",
    "csv_fname=job_type+'_'+topology_name.replace(' ', '_')+'.csv'\n",
    "perfp=PerfPresenter()\n",
    "perfp.create_csv_logfile(job_type, csv_fname)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3:  Run the benchmark "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*****************************************\n",
      "Setting OMP_NUM_THREADS environment variable for each process to be 1 in default, to avoid your system being overloaded, please further tune the variable for optimal performance in your application as needed. \n",
      "*****************************************\n"
     ]
    }
   ],
   "source": [
    "launch.main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 4: Parse output for performance number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Found the file path of the related runtime log."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/tmp/models/docs/notebooks/perf_analysis/pytorch/logs/vgg16_infer_fp32.log\n"
     ]
    }
   ],
   "source": [
    "# identify the path of the latest log file\n",
    "configvals=config.read_config(topology_name)\n",
    "used_logpath = log_path\n",
    "print(used_logpath)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Parse the logfile for performance number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "get throughput\n",
      "inference performance 5.456 fps\n",
      "\n",
      "5.456\n",
      "5.456\n"
     ]
    }
   ],
   "source": [
    "if accuracy_only == False:\n",
    "    print(\"get throughput\")\n",
    "    val = config.throughput_keyword\n",
    "    index = int(config.throughput_index)\n",
    "    line = perfp.read_throughput(used_logpath, keyword=val, index=index)\n",
    "    if line!=None:\n",
    "        throughput=line\n",
    "        print(throughput)\n",
    "        # log the perf number\n",
    "        perfp.log_infer_perfcsv(0, throughput, 0, csv_fname, ipex_enabled = has_ipex)\n",
    "    else:\n",
    "        print(\"ERROR! can't find correct performance number from log. please check log for runtime issues\")\n",
    "else:\n",
    "    # get accuracy number and caculate throughput\n",
    "    print(\"get accuracy and throughput\")\n",
    "    #val = config.throughput_keyword\n",
    "    #index = int(config.throughput_index)\n",
    "    accuracy = perfp.read_accuracy(used_logpath)\n",
    "    iternation = perfp.read_iteration_time(used_logpath)\n",
    "    if accuracy != [] and iternation != []:\n",
    "        final_accuracy=accuracy[-1]\n",
    "        iternation_time = iternation[-1]\n",
    "        throughput = float(batch_size)/iternation_time\n",
    "        print(final_accuracy,throughput)\n",
    "        # log the perf number\n",
    "        perfp.log_infer_perfcsv(0, throughput, final_accuracy, csv_fname)\n",
    "    else:\n",
    "        print(\"ERROR! can't find correct performance number from log. please check log for runtime issues\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Optional : print out the log file for runtime issues"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=> using pre-trained model 'vgg16'\n",
      "using CPU, this will be slow\n",
      "using ipex model to do inference\n",
      "running jit fusion path\n",
      "using dummy input data to run\n",
      "Test: [ 0/50]\tTime  0.000 ( 0.000)\tLoss 9.0608e+00 (9.0608e+00)\tAcc@1   0.00 (  0.00)\tAcc@5   0.00 (  0.00)\n",
      "Test: [10/50]\tTime  0.000 ( 0.000)\tLoss 9.0608e+00 (9.0608e+00)\tAcc@1   0.00 (  0.00)\tAcc@5   0.00 (  0.00)\n",
      "Test: [20/50]\tTime  0.000 ( 0.000)\tLoss 9.0608e+00 (9.0608e+00)\tAcc@1   0.00 (  0.00)\tAcc@5   0.00 (  0.00)\n",
      "Test: [30/50]\tTime  5.866 ( 5.866)\tLoss 9.0608e+00 (9.0608e+00)\tAcc@1   0.00 (  0.00)\tAcc@5   0.00 (  0.00)\n",
      "Test: [40/50]\tTime  5.867 ( 5.867)\tLoss 9.0608e+00 (9.0608e+00)\tAcc@1   0.00 (  0.00)\tAcc@5   0.00 (  0.00)\n",
      "inference latency 183.273 ms\n",
      "inference performance 5.456 fps\n",
      " * Acc@1 0.000 Acc@5 0.000\n",
      "DoneClosing\n"
     ]
    }
   ],
   "source": [
    "logfile = open(used_logpath)\n",
    "logout = logfile.read()\n",
    "print(logout)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 5: Draw the performance comparison diagram\n",
    ">NOTE: Please go over Section 1 on different Jupyter kernel before comparison\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "%matplotlib inline\n",
    "from profiling.profile_utils import PerfPresenter\n",
    "\n",
    "perfp=PerfPresenter(True)\n",
    "# inference  throughput\n",
    "perfp.draw_perf_diag_from_csv(csv_fname,'throughput','throughput (image/sec)', topology_name)\n",
    "perfp.draw_perf_ratio_diag_from_csv(csv_fname,'throughput','speedup', topology_name)\n",
    "if accuracy_only == True:\n",
    "    perfp.draw_perf_diag_from_csv(csv_fname,'accuracy','accuracy', topology_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "intel-torch",
   "language": "python",
   "name": "intel-torch"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
